home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Tech Arsenal 1
/
Tech Arsenal (Arsenal Computer).ISO
/
tek-04
/
timer11.zip
/
ZTIMER.H
< prev
next >
Wrap
C/C++ Source or Header
|
1992-04-21
|
8KB
|
262 lines
/****************************************************************************
*
* The Zen Timer Library
*
* From the book
* "Zen of Assembly Language"
* Volume 1, Knowledge
*
* by Michael Abrash
*
* Modifications by Kendall Bennett
*
* Filename: $RCSfile: ztimer.h $
* Version: $Revision: 1.9 $
*
* Language: ANSI C, C++ 2.1
* Environment: IBM PC (MS DOS)
*
* Description: Header file for the Zen Timer library. Provides a number
* of routines to accurately time segments of code. A
* precision timer is provided for highly accurate timing of
* code that takes less than 54 ms to execute, and a long
* period timer is provided to time code that takes up to
* one hour to execute. All output is in microseconds.
*
* The ultra long period timer can be used to time code
* that takes up to 24 hours to execute (raytracing
* etc).
*
* We also now provide a set of C++ classes to manipulate
* the Zen Timers. Note that you can only have one timer
* running at a time!! Note that all of the code is inline
* to make it memory model independant, and to avoid the
* extra cost of a function call overhead in the C++ wrappers.
*
* $Id: ztimer.h 1.9 92/04/21 01:19:51 kjb release $
*
* Revision History:
* -----------------
*
* $Log: ztimer.h $
* Revision 1.9 92/04/21 01:19:51 kjb
* Converted to memory model dependant library.
*
* Revision 1.8 92/04/21 00:47:55 kjb
* Fixed code to be memory model independant.
*
* Revision 1.7 92/04/20 23:30:52 kjb
* Cosmetic changes.
*
* Revision 1.6 92/04/20 17:35:07 kjb
* Added C++ classes to manipulate the timers.
* ./
*
* Revision 1.5 92/01/27 21:40:01 kjb
* Converted to a memory model independant library, and released to the
* public.,
*
* Revision 1.4 91/12/31 19:34:51 kjb
* Changed include file directories.
*
* Revision 1.3 91/12/26 17:56:38 kjb
* Added dependency on DEBUG.H
*
* Revision 1.2 91/11/16 17:12:20 kjb
* Modified to return a long integer representing the count rather than a
* string.
*
* Revision 1.1 91/11/14 17:19:58 kjb
* Initial revision
*
****************************************************************************/
#ifndef __ZTIMER_H
#define __ZTIMER_H
#ifndef __DEBUG_H
#include "debug.h"
#endif
/*-------------------------- Function Prototypes --------------------------*/
#ifdef __cplusplus
extern "C" { /* Use "C" linkage when in C++ mode */
#endif
/* Precision timing routines in PZTIMER.ASM */
void far PZTimerOn(void);
void far PZTimerOff(void);
void far PZTimerReport(void);
ulong far PZTimerCount(void);
/* Long period timing routines in LZTIMER.ASM */
void far LZTimerOn(void);
void far LZTimerOff(void);
void far LZTimerReport(void);
ulong far LZTimerCount(void);
/* Ultra long period timing routines in TIMER.C */
ulong ULZReadTime(void);
ulong ULZElapsedTime(ulong start,ulong finish);
#ifdef __cplusplus
} /* End of "C" linkage for C++ */
#endif
/*--------------------------- Class Definitions ---------------------------*/
#ifdef __cplusplus
#ifndef __IOSTREAM_H
#include <iostream.h>
#endif
//---------------------------------------------------------------------------
// Precision Zen Timer class. This can be used to time code that takes up
// to 54 ms to execute between calls to start() and stop() or lap(). The
// aggregate count can be up to 2^32 - 1 microseconds (about 1 hour
// and 10 mins).
//---------------------------------------------------------------------------
class PZTimer {
protected:
ulong _count; // Running count
short _overflow; // Flags an overflow
public:
// Constructor
PZTimer() { _count = 0; _overflow = false; };
// Method to start the timer
void start() { PZTimerOn(); };
// Method to restart the timer
void restart() { reset(); start(); };
// Method to stop the timer
void stop()
{
PZTimerOff();
if (!overflow()) {
ulong newcount = _count + PZTimerCount();
if (newcount < _count || newcount == 0xFFFFFFFF)
_overflow = true;
else
_count = newcount;
}
};
// Method to return the current count
ulong count() { return overflow() ? 0xFFFFFFFF : _count; };
// Method to reset the timer to a zero count
void reset() { _count = 0; _overflow = false; };
// Method to determine if overflow occurred
bool overflow() { return _overflow; };
// Method to return timer resolution (counts in a second).
ulong resolution() { return 1000000L; };
// Method to display the timed count in seconds
friend ostream& operator << (ostream& o,PZTimer& timer);
};
//---------------------------------------------------------------------------
// Long Period Zen Timer class. This can be used to time code that takes up
// to 1 hour to execute between calls to start() and stop() or lap(). The
// aggregate count can be up to 2^32 - 1 microseconds (about 1 hour
// and 10 mins).
//---------------------------------------------------------------------------
class LZTimer {
protected:
ulong _count;
short _overflow;
public:
// Constructor
LZTimer() { _count = 0; _overflow = false; };
// Method to start the timer
void start() { LZTimerOn(); };
// Method to restart the timer
void restart() { reset(); start(); };
// Method to stop the timer
void stop()
{
LZTimerOff();
if (!overflow()) {
ulong newcount = _count + LZTimerCount();
if (newcount < _count || newcount == 0xFFFFFFFF)
_overflow = true;
else
_count = newcount;
}
};
// Method to return the current count
ulong count() { return overflow() ? 0xFFFFFFFF : _count; };
// Method to reset the timer to a zero count
void reset() { _count = 0; _overflow = false; };
// Method to determine if overflow occurred
bool overflow() { return _overflow; };
// Method to return timer resolution (counts in a second).
ulong resolution() { return 1000000L; };
// Method to display the timed count in seconds
friend ostream& operator << (ostream& o,LZTimer& timer);
};
//---------------------------------------------------------------------------
// Ultra Long Period Zen Timer class. This can be used to time code that
// takes up 24 hours total to execute between calls to start() and stop().
// The aggregate count can be up to 2^32 - 1 tenths of a second, which
// is about 119,000 hours! Should be enough for most applications.
//---------------------------------------------------------------------------
class ULZTimer {
protected:
ulong _count,_start,_finish;
short _overflow;
public:
// Constructor
ULZTimer() { _count = 0; _overflow = false; };
// Method to start the timer
void start() { _start = ULZReadTime(); };
// Method to restart the timer
void restart() { reset(); start(); };
// Method to stop the timer
void stop();
// Method to return the current count
ulong count() { return overflow() ? 0xFFFFFFFF : _count; };
// Method to reset the timer to a zero count
void reset() { _count = 0; _overflow = false; };
// Method to determine if overflow occurred
bool overflow() { return _overflow; };
// Method to return timer resolution (counts in a second).
ulong resolution() { return 10L; };
// Method to display the timed count in seconds
friend ostream& operator << (ostream& o,ULZTimer& timer);
};
#endif
#endif __ZTIMER_H